Personal Computer World 2009 February/PCWFEB09.iso/Software/Resources/Chat & Communication/Digsby build 37/digsby_setup.exe/lib/protocols/tests/doctest.pyo

Python Compiled Bytecode | 2008-10-13 | 44KB | 1,350 lines

# Source Generated with Decompyle++
# File: in.pyo (Python 2.5)


try:
    basestring
except NameError:
    basestring = (str, unicode)


try:
    enumerate
except NameError:

    def enumerate(seq):
        return zip(range(len(seq)), seq)


__docformat__ = 'reStructuredText en'
__all__ = [
    'register_optionflag',
    'DONT_ACCEPT_TRUE_FOR_1',
    'DONT_ACCEPT_BLANKLINE',
    'NORMALIZE_WHITESPACE',
    'ELLIPSIS',
    'IGNORE_EXCEPTION_DETAIL',
    'COMPARISON_FLAGS',
    'REPORT_UDIFF',
    'REPORT_CDIFF',
    'REPORT_NDIFF',
    'REPORT_ONLY_FIRST_FAILURE',
    'REPORTING_FLAGS',
    'is_private',
    'Example',
    'DocTest',
    'DocTestParser',
    'DocTestFinder',
    'DocTestRunner',
    'OutputChecker',
    'DocTestFailure',
    'UnexpectedException',
    'DebugRunner',
    'testmod',
    'testfile',
    'run_docstring_examples',
    'Tester',
    'DocTestSuite',
    'DocFileSuite',
    'set_unittest_reportflags',
    'script_from_examples',
    'testsource',
    'debug_src',
    'debug']
import __future__
import sys
import traceback
import inspect
import linecache
import os
import re
import types
import unittest
import difflib
import pdb
import tempfile
import warnings
from StringIO import StringIO
warnings.filterwarnings('ignore', 'is_private', DeprecationWarning, __name__, 0)
OPTIONFLAGS_BY_NAME = { }

def register_optionflag(name):
    flag = 1 << len(OPTIONFLAGS_BY_NAME)
    OPTIONFLAGS_BY_NAME[name] = flag
    return flag

DONT_ACCEPT_TRUE_FOR_1 = register_optionflag('DONT_ACCEPT_TRUE_FOR_1')
DONT_ACCEPT_BLANKLINE = register_optionflag('DONT_ACCEPT_BLANKLINE')
NORMALIZE_WHITESPACE = register_optionflag('NORMALIZE_WHITESPACE')
ELLIPSIS = register_optionflag('ELLIPSIS')
IGNORE_EXCEPTION_DETAIL = register_optionflag('IGNORE_EXCEPTION_DETAIL')
COMPARISON_FLAGS = DONT_ACCEPT_TRUE_FOR_1 | DONT_ACCEPT_BLANKLINE | NORMALIZE_WHITESPACE | ELLIPSIS | IGNORE_EXCEPTION_DETAIL
REPORT_UDIFF = register_optionflag('REPORT_UDIFF')
REPORT_CDIFF = register_optionflag('REPORT_CDIFF')
REPORT_NDIFF = register_optionflag('REPORT_NDIFF')
REPORT_ONLY_FIRST_FAILURE = register_optionflag('REPORT_ONLY_FIRST_FAILURE')
REPORTING_FLAGS = REPORT_UDIFF | REPORT_CDIFF | REPORT_NDIFF | REPORT_ONLY_FIRST_FAILURE
BLANKLINE_MARKER = '<BLANKLINE>'
ELLIPSIS_MARKER = '...'

def is_private(prefix, base):
    warnings.warn("is_private is deprecated; it wasn't useful; examine DocTestFinder.find() lists instead", DeprecationWarning, stacklevel = 2)
    if base[:1] == '_':
        pass
    return not None if '__' == '__' else '__' == base[-2:]


def _extract_future_flags(globs):
    flags = 0
    for fname in __future__.all_feature_names:
        feature = globs.get(fname, None)
        if feature is getattr(__future__, fname):
            flags |= feature.compiler_flag
            continue

    return flags


def _normalize_module(module, depth = 2):
    if inspect.ismodule(module):
        return module
    elif isinstance(module, (str, unicode)):
        return __import__(module, globals(), locals(), [
            '*'])
    elif module is None:
        return sys.modules[sys._getframe(depth).f_globals['__name__']]
    else:
        raise TypeError('Expected a module, string, or None')


def _indent(s, indent = 4):
    return re.sub('(?m)^(?!$)', indent * ' ', s)


def _exception_traceback(exc_info):
    excout = StringIO()
    (exc_type, exc_val, exc_tb) = exc_info
    traceback.print_exception(exc_type, exc_val, exc_tb, file = excout)
    return excout.getvalue()


class _SpoofOut(StringIO):

    def getvalue(self):
        result = StringIO.getvalue(self)
        if result and not result.endswith('\n'):
            result += '\n'

        if hasattr(self, 'softspace'):
            del self.softspace

        return result


    def truncate(self, size = None):
        StringIO.truncate(self, size)
        if hasattr(self, 'softspace'):
            del self.softspace




def _ellipsis_match(want, got):
    if want.find(ELLIPSIS_MARKER) == -1:
        return want == got

    ws = want.split(ELLIPSIS_MARKER)
    startpos = 0
    endpos = len(got)
    w = ws[0]
    if w:
        if got.startswith(w):
            startpos = len(w)
            del ws[0]
        else:
            return False

    w = ws[-1]
    if w:
        if got.endswith(w):
            endpos -= len(w)
            del ws[-1]
        else:
            return False

    if startpos > endpos:
        return False

    for w in ws:
        startpos = got.find(w, startpos, endpos)
        if startpos < 0:
            return False

        startpos += len(w)

    return True


def _comment_line(line):
    line = line.rstrip()
    if line:
        return '# ' + line
    else:
        return '#'


class _OutputRedirectingPdb(pdb.Pdb):

    def __init__(self, out):
        self._OutputRedirectingPdb__out = out
        pdb.Pdb.__init__(self)


    def trace_dispatch(self, *args):
        save_stdout = sys.stdout
        sys.stdout = self._OutputRedirectingPdb__out

        try:
            return pdb.Pdb.trace_dispatch(self, *args)
        finally:
            sys.stdout = save_stdout




def _module_relative_path(module, path):
    if not inspect.ismodule(module):
        raise TypeError, 'Expected a module: %r' % module

    if path.startswith('/'):
        raise ValueError, 'Module-relative files may not have absolute paths'

    if hasattr(module, '__file__'):
        basedir = os.path.split(module.__file__)[0]
    elif module.__name__ == '__main__':
        if len(sys.argv) > 0 and sys.argv[0] != '':
            basedir = os.path.split(sys.argv[0])[0]
        else:
            basedir = os.curdir
    else:
        raise ValueError("Can't resolve paths relative to the module " + module + ' (it has no __file__)')
    return os.path.join(basedir, *path.split('/'))


class Example:

    def __init__(self, source, want, exc_msg = None, lineno = 0, indent = 0, options = None):
        if not source.endswith('\n'):
            source += '\n'

        if want and not want.endswith('\n'):
            want += '\n'

        if exc_msg is not None and not exc_msg.endswith('\n'):
            exc_msg += '\n'

        self.source = source
        self.want = want
        self.lineno = lineno
        self.indent = indent
        if options is None:
            options = { }

        self.options = options
        self.exc_msg = exc_msg



class DocTest:

    def __init__(self, examples, globs, name, filename, lineno, docstring):
        self.examples = examples
        self.docstring = docstring
        self.globs = globs.copy()
        self.name = name
        self.filename = filename
        self.lineno = lineno


    def __repr__(self):
        if len(self.examples) == 0:
            examples = 'no examples'
        elif len(self.examples) == 1:
            examples = '1 example'
        else:
            examples = '%d examples' % len(self.examples)
        return '<DocTest %s from %s:%s (%s)>' % (self.name, self.filename, self.lineno, examples)


    def __cmp__(self, other):
        if not isinstance(other, DocTest):
            return -1

        return cmp((self.name, self.filename, self.lineno, id(self)), (other.name, other.filename, other.lineno, id(other)))



class DocTestParser:
    _EXAMPLE_RE = re.compile('\n        # Source consists of a PS1 line followed by zero or more PS2 lines.\n        (?P<source>\n            (?:^(?P<indent> [ ]*) >>>    .*)    # PS1 line\n            (?:\\n           [ ]*  \\.\\.\\. .*)*)  # PS2 lines\n        \\n?\n        # Want consists of any non-blank lines that do not start with PS1.\n        (?P<want> (?:(?![ ]*$)    # Not a blank line\n                     (?![ ]*>>>)  # Not a line starting with PS1\n                     .*$\\n?       # But any other line\n                  )*)\n        ', re.MULTILINE | re.VERBOSE)
    _EXCEPTION_RE = re.compile("\n        # Grab the traceback header.  Different versions of Python have\n        # said different things on the first traceback line.\n        ^(?P<hdr> Traceback\\ \\(\n            (?: most\\ recent\\ call\\ last\n            |   innermost\\ last\n            ) \\) :\n        )\n        \\s* $                # toss trailing whitespace on the header.\n        (?P<stack> .*?)      # don't blink: absorb stuff until...\n        ^ (?P<msg> \\w+ .*)   #     a line *starts* with alphanum.\n        ", re.VERBOSE | re.MULTILINE | re.DOTALL)
    _IS_BLANK_OR_COMMENT = re.compile('^[ ]*(#.*)?$').match

    def parse(self, string, name = '<string>'):
        string = string.expandtabs()
        min_indent = self._min_indent(string)
        output = []
        (charno, lineno) = (0, 0)
        for m in self._EXAMPLE_RE.finditer(string):
            output.append(string[charno:m.start()])
            lineno += string.count('\n', charno, m.start())
            (source, options, want, exc_msg) = self._parse_example(m, name, lineno)
            if not self._IS_BLANK_OR_COMMENT(source):
                output.append(Example(source, want, exc_msg, lineno = lineno, indent = min_indent + len(m.group('indent')), options = options))

            lineno += string.count('\n', m.start(), m.end())
            charno = m.end()

        output.append(string[charno:])
        return output


    def get_doctest(self, string, globs, name, filename, lineno):
        return DocTest(self.get_examples(string, name), globs, name, filename, lineno, string)


    def get_examples(self, string, name = '<string>'):
        return _[1]


    def _parse_example(self, m, name, lineno):
        indent = len(m.group('indent'))
        source_lines = m.group('source').split('\n')
        self._check_prompt_blank(source_lines, indent, name, lineno)
        self._check_prefix(source_lines[1:], ' ' * indent + '.', name, lineno)
        source = []([ sl[indent + 4:] for sl in source_lines ])
        want = m.group('want')
        want_lines = want.split('\n')
        self._check_prefix(want_lines, ' ' * indent, name, lineno + len(source_lines))
        want = []([ wl[indent:] for wl in want_lines ])
        m = self._EXCEPTION_RE.match(want)
        options = self._find_options(source, name, lineno)
        return (source, options, want, exc_msg)

    _OPTION_DIRECTIVE_RE = re.compile('#\\s*doctest:\\s*([^\\n\\\'"]*)$', re.MULTILINE)

    def _find_options(self, source, name, lineno):
        options = { }
        for m in self._OPTION_DIRECTIVE_RE.finditer(source):
            option_strings = m.group(1).replace(',', ' ').split()
            for option in option_strings:
                if option[0] not in '+-' or option[1:] not in OPTIONFLAGS_BY_NAME:
                    raise ValueError('line %r of the doctest for %s has an invalid option: %r' % (lineno + 1, name, option))

                flag = OPTIONFLAGS_BY_NAME[option[1:]]
                options[flag] = option[0] == '+'


        if options and self._IS_BLANK_OR_COMMENT(source):
            raise ValueError('line %r of the doctest for %s has an option directive on a line with no example: %r' % (lineno, name, source))

        return options

    _INDENT_RE = re.compile('^([ ]*)(?=\\S)', re.MULTILINE)

    def _min_indent(self, s):
        indents = [ len(indent) for indent in self._INDENT_RE.findall(s) ]


    def _check_prompt_blank(self, lines, indent, name, lineno):
        for i, line in enumerate(lines):
            if len(line) >= indent + 4 and line[indent + 3] != ' ':
                raise ValueError('line %r of the docstring for %s lacks blank after %s: %r' % (lineno + i + 1, name, line[indent:indent + 3], line))
                continue



    def _check_prefix(self, lines, prefix, name, lineno):
        for i, line in enumerate(lines):
            if line and not line.startswith(prefix):
                raise ValueError('line %r of the docstring for %s has inconsistent leading whitespace: %r' % (lineno + i + 1, name, line))
                continue




class DocTestFinder:

    def __init__(self, verbose = False, parser = DocTestParser(), recurse = True, _namefilter = None, exclude_empty = True):
        self._parser = parser
        self._verbose = verbose
        self._recurse = recurse
        self._exclude_empty = exclude_empty
        self._namefilter = _namefilter


    def find(self, obj, name = None, module = None, globs = None, extraglobs = None):
        if name is None:
            name = getattr(obj, '__name__', None)
            if name is None:
                raise ValueError("DocTestFinder.find: name must be given when obj.__name__ doesn't exist: %r" % (type(obj),))


        if module is False:
            module = None
        elif module is None:
            module = inspect.getmodule(obj)


        try:
            if not inspect.getsourcefile(obj):
                pass
            file = inspect.getfile(obj)
            source_lines = linecache.getlines(file)
            if not source_lines:
                source_lines = None
        except TypeError:
            source_lines = None

        if globs is None:
            if module is None:
                globs = { }
            else:
                globs = module.__dict__.copy()
        else:
            globs = globs.copy()
        if extraglobs is not None:
            globs.update(extraglobs)

        tests = []
        self._find(tests, obj, name, module, source_lines, globs, { })
        return tests


    def _filter(self, obj, prefix, base):
        if self._namefilter is not None:
            pass
        return self._namefilter(prefix, base)


    def _from_module(self, module, object):
        if module is None:
            return True
        elif inspect.isfunction(object):
            return module.__dict__ is object.func_globals
        elif inspect.isclass(object):
            return module.__name__ == object.__module__
        elif inspect.getmodule(object) is not None:
            return module is inspect.getmodule(object)
        elif hasattr(object, '__module__'):
            return module.__name__ == object.__module__
        elif isinstance(object, property):
            return True
        else:
            raise ValueError('object must be a class or function')


    def _find(self, tests, obj, name, module, source_lines, globs, seen):
        if self._verbose:
            print 'Finding tests in %s' % name

        if id(obj) in seen:
            return None

        seen[id(obj)] = 1
        test = self._get_test(obj, name, module, globs, source_lines)
        if test is not None:
            tests.append(test)

        if inspect.ismodule(obj) and self._recurse:
            for valname, val in obj.__dict__.items():
                if self._filter(val, name, valname):
                    continue

                valname = '%s.%s' % (name, valname)
                if (inspect.isfunction(val) or inspect.isclass(val)) and self._from_module(module, val):
                    self._find(tests, val, valname, module, source_lines, globs, seen)
                    continue


        if inspect.ismodule(obj) and self._recurse:
            for valname, val in getattr(obj, '__test__', { }).items():
                if not isinstance(valname, basestring):
                    raise ValueError('DocTestFinder.find: __test__ keys must be strings: %r' % (type(valname),))

                if not inspect.isfunction(val) and inspect.isclass(val) and inspect.ismethod(val) and inspect.ismodule(val) or isinstance(val, basestring):
                    raise ValueError('DocTestFinder.find: __test__ values must be strings, functions, methods, classes, or modules: %r' % (type(val),))

                valname = '%s.__test__.%s' % (name, valname)
                self._find(tests, val, valname, module, source_lines, globs, seen)


        if inspect.isclass(obj) and self._recurse:
            for valname, val in obj.__dict__.items():
                if self._filter(val, name, valname):
                    continue

                if isinstance(val, staticmethod):
                    val = getattr(obj, valname)

                if isinstance(val, classmethod):
                    val = getattr(obj, valname).im_func

                if (inspect.isfunction(val) and inspect.isclass(val) or isinstance(val, property)) and self._from_module(module, val):
                    valname = '%s.%s' % (name, valname)
                    self._find(tests, val, valname, module, source_lines, globs, seen)
                    continue




    def _get_test(self, obj, name, module, globs, source_lines):
        if isinstance(obj, basestring):
            docstring = obj
        else:

            try:
                if obj.__doc__ is None:
                    docstring = ''
                else:
                    docstring = obj.__doc__
                    if not isinstance(docstring, basestring):
                        docstring = str(docstring)
            except (TypeError, AttributeError):
                docstring = ''


        lineno = self._find_lineno(obj, source_lines)
        if self._exclude_empty and not docstring:
            return None

        if module is None:
            filename = None
        else:
            filename = getattr(module, '__file__', module.__name__)
            if filename[-4:] in ('.pyc', '.pyo'):
                filename = filename[:-1]

        return self._parser.get_doctest(docstring, globs, name, filename, lineno)


    def _find_lineno(self, obj, source_lines):
        lineno = None
        if inspect.ismodule(obj):
            lineno = 0

        if inspect.isclass(obj):
            if source_lines is None:
                return None

            pat = re.compile('^\\s*class\\s*%s\\b' % getattr(obj, '__name__', '-'))
            for i, line in enumerate(source_lines):
                if pat.match(line):
                    lineno = i
                    break
                    continue


        if inspect.ismethod(obj):
            obj = obj.im_func

        if inspect.isfunction(obj):
            obj = obj.func_code

        if inspect.istraceback(obj):
            obj = obj.tb_frame

        if inspect.isframe(obj):
            obj = obj.f_code

        if inspect.iscode(obj):
            lineno = getattr(obj, 'co_firstlineno', None) - 1

        if lineno is not None:
            if source_lines is None:
                return lineno + 1

            pat = re.compile('(^|.*:)\\s*\\w*("|\')')
            for lineno in range(lineno, len(source_lines)):
                if pat.match(source_lines[lineno]):
                    return lineno
                    continue





class DocTestRunner:
    DIVIDER = '*' * 70

    def __init__(self, checker = None, verbose = None, optionflags = 0):
        if not checker:
            pass
        self._checker = OutputChecker()
        if verbose is None:
            verbose = '-v' in sys.argv

        self._verbose = verbose
        self.optionflags = optionflags
        self.original_optionflags = optionflags
        self.tries = 0
        self.failures = 0
        self._name2ft = { }
        self._fakeout = _SpoofOut()


    def report_start(self, out, test, example):
        if self._verbose:
            if example.want:
                out('Trying:\n' + _indent(example.source) + 'Expecting:\n' + _indent(example.want))
            else:
                out('Trying:\n' + _indent(example.source) + 'Expecting nothing\n')



    def report_success(self, out, test, example, got):
        if self._verbose:
            out('ok\n')



    def report_failure(self, out, test, example, got):
        out(self._failure_header(test, example) + self._checker.output_difference(example, got, self.optionflags))


    def report_unexpected_exception(self, out, test, example, exc_info):
        out(self._failure_header(test, example) + 'Exception raised:\n' + _indent(_exception_traceback(exc_info)))


    def _failure_header(self, test, example):
        out = [
            self.DIVIDER]
        if test.filename:
            if test.lineno is not None and example.lineno is not None:
                lineno = test.lineno + example.lineno + 1
            else:
                lineno = '?'
            out.append('File "%s", line %s, in %s' % (test.filename, lineno, test.name))
        else:
            out.append('Line %s, in %s' % (example.lineno + 1, test.name))
        out.append('Failed example:')
        source = example.source
        out.append(_indent(source))
        return '\n'.join(out)


    def __run(self, test, compileflags, out):
        failures = tries = 0
        original_optionflags = self.optionflags
        (SUCCESS, FAILURE, BOOM) = range(3)
        check = self._checker.check_output
        for examplenum, example in enumerate(test.examples):
            if self.optionflags & REPORT_ONLY_FIRST_FAILURE:
                pass
            quiet = failures > 0
            self.optionflags = original_optionflags
            if example.options:
                for optionflag, val in example.options.items():
                    if val:
                        self.optionflags |= optionflag
                        continue
                    self
                    self.optionflags &= ~optionflag


            tries += 1
            if not quiet:
                self.report_start(out, test, example)

            filename = '<doctest %s[%d]>' % (test.name, examplenum)

            try:
                exec compile(example.source, filename, 'single', compileflags, 1) in test.globs
                self.debugger.set_continue()
                exception = None
            except KeyboardInterrupt:
                raise
            except:
                exception = sys.exc_info()
                self.debugger.set_continue()

            got = self._fakeout.getvalue()
            self._fakeout.truncate(0)
            outcome = FAILURE
            if exception is None:
                if check(example.want, got, self.optionflags):
                    outcome = SUCCESS

            else:
                exc_info = sys.exc_info()
                exc_msg = traceback.format_exception_only(*exc_info[:2])[-1]
                if not quiet:
                    got += _exception_traceback(exc_info)

                if example.exc_msg is None:
                    outcome = BOOM
                elif check(example.exc_msg, exc_msg, self.optionflags):
                    outcome = SUCCESS
                elif self.optionflags & IGNORE_EXCEPTION_DETAIL:
                    m1 = re.match('[^:]*:', example.exc_msg)
                    m2 = re.match('[^:]*:', exc_msg)
                    if m1 and m2 and check(m1.group(0), m2.group(0), self.optionflags):
                        outcome = SUCCESS


            if outcome is SUCCESS:
                if not quiet:
                    self.report_success(out, test, example, got)

            quiet
            if outcome is FAILURE:
                if not quiet:
                    self.report_failure(out, test, example, got)

                failures += 1
                continue
            if outcome is BOOM:
                if not quiet:
                    self.report_unexpected_exception(out, test, example, exc_info)

                failures += 1
                continue

        self.optionflags = original_optionflags
        self._DocTestRunner__record_outcome(test, failures, tries)
        return (failures, tries)


    def __record_outcome(self, test, f, t):
        (f2, t2) = self._name2ft.get(test.name, (0, 0))
        self._name2ft[test.name] = (f + f2, t + t2)
        self.failures += f
        self.tries += t

    __LINECACHE_FILENAME_RE = re.compile('<doctest (?P<name>[\\w\\.]+)\\[(?P<examplenum>\\d+)\\]>$')

    def __patched_linecache_getlines(self, filename, module_globals = None):
        m = self._DocTestRunner__LINECACHE_FILENAME_RE.match(filename)
        if m and m.group('name') == self.test.name:
            example = self.test.examples[int(m.group('examplenum'))]
            return example.source.splitlines(True)
        elif self.save_linecache_getlines.func_code.co_argcount > 1:
            return self.save_linecache_getlines(filename, module_globals)
        else:
            return self.save_linecache_getlines(filename)


    def run(self, test, compileflags = None, out = None, clear_globs = True):
        self.test = test
        if compileflags is None:
            compileflags = _extract_future_flags(test.globs)

        save_stdout = sys.stdout
        if out is None:
            out = save_stdout.write

        sys.stdout = self._fakeout
        save_set_trace = pdb.set_trace
        self.debugger = _OutputRedirectingPdb(save_stdout)
        self.debugger.reset()
        pdb.set_trace = self.debugger.set_trace
        self.save_linecache_getlines = linecache.getlines
        linecache.getlines = self._DocTestRunner__patched_linecache_getlines

        try:
            return self._DocTestRunner__run(test, compileflags, out)
        finally:
            sys.stdout = save_stdout
            pdb.set_trace = save_set_trace
            linecache.getlines = self.save_linecache_getlines
            if clear_globs:
                test.globs.clear()




    def summarize(self, verbose = None):
        if verbose is None:
            verbose = self._verbose

        notests = []
        passed = []
        failed = []
        totalt = totalf = 0
        for x in self._name2ft.items():
            (f, t) = (name,)
            totalt += t
            totalf += f
            if t == 0:
                notests.append(name)
                continue
            x
            if f == 0:
                passed.append((name, t))
                continue
            failed.append(x)

        if verbose:
            if notests:
                print len(notests), 'items had no tests:'
                notests.sort()
                for thing in notests:
                    print '   ', thing


            if passed:
                print len(passed), 'items passed all tests:'
                passed.sort()
                for thing, count in passed:
                    print ' %3d tests in %s' % (count, thing)



        if failed:
            print self.DIVIDER
            print len(failed), 'items had failures:'
            failed.sort()
            for f, t in failed:
                print ' %3d of %3d in %s' % (f, t, thing)


        if verbose:
            print totalt, 'tests in', len(self._name2ft), 'items.'
            print totalt - totalf, 'passed and', totalf, 'failed.'

        if totalf:
            print '***Test Failed***', totalf, 'failures.'
        elif verbose:
            print 'Test passed.'

        return (totalf, totalt)


    def merge(self, other):
        d = self._name2ft
        for f, t in other._name2ft.items():
            d[name] = (f, t)




class OutputChecker:

    def check_output(self, want, got, optionflags):
        if got == want:
            return True

        if not optionflags & DONT_ACCEPT_TRUE_FOR_1:
            if (got, want) == ('True\n', '1\n'):
                return True

            if (got, want) == ('False\n', '0\n'):
                return True


        if not optionflags & DONT_ACCEPT_BLANKLINE:
            want = re.sub('(?m)^%s\\s*?$' % re.escape(BLANKLINE_MARKER), '', want)
            got = re.sub('(?m)^\\s*?$', '', got)
            if got == want:
                return True


        if optionflags & NORMALIZE_WHITESPACE:
            got = ' '.join(got.split())
            want = ' '.join(want.split())
            if got == want:
                return True


        if optionflags & ELLIPSIS:
            if _ellipsis_match(want, got):
                return True


        return False


    def _do_a_fancy_diff(self, want, got, optionflags):
        if not optionflags & (REPORT_UDIFF | REPORT_CDIFF | REPORT_NDIFF):
            return False

        if optionflags & REPORT_NDIFF:
            return True

        if want.count('\n') > 2:
            pass
        return got.count('\n') > 2


    def output_difference(self, example, got, optionflags):
        want = example.want
        if not optionflags & DONT_ACCEPT_BLANKLINE:
            got = re.sub('(?m)^[ ]*(?=\n)', BLANKLINE_MARKER, got)

        if want and got:
            return 'Expected:\n%sGot:\n%s' % (_indent(want), _indent(got))
        elif want:
            return 'Expected:\n%sGot nothing\n' % _indent(want)
        elif got:
            return 'Expected nothing\nGot:\n%s' % _indent(got)
        else:
            return 'Expected nothing\nGot nothing\n'



class DocTestFailure(Exception):

    def __init__(self, test, example, got):
        self.test = test
        self.example = example
        self.got = got


    def __str__(self):
        return str(self.test)



class UnexpectedException(Exception):

    def __init__(self, test, example, exc_info):
        self.test = test
        self.example = example
        self.exc_info = exc_info


    def __str__(self):
        return str(self.test)



class DebugRunner(DocTestRunner):

    def run(self, test, compileflags = None, out = None, clear_globs = True):
        r = DocTestRunner.run(self, test, compileflags, out, False)
        if clear_globs:
            test.globs.clear()

        return r


    def report_unexpected_exception(self, out, test, example, exc_info):
        raise UnexpectedException(test, example, exc_info)


    def report_failure(self, out, test, example, got):
        raise DocTestFailure(test, example, got)


master = None

def testmod(m = None, name = None, globs = None, verbose = None, isprivate = None, report = True, optionflags = 0, extraglobs = None, raise_on_error = False, exclude_empty = False):
    global master
    if isprivate is not None:
        warnings.warn('the isprivate argument is deprecated; examine DocTestFinder.find() lists instead', DeprecationWarning)

    if m is None:
        m = sys.modules.get('__main__')

    if not inspect.ismodule(m):
        raise TypeError('testmod: module required; %r' % (m,))

    if name is None:
        name = m.__name__

    finder = DocTestFinder(_namefilter = isprivate, exclude_empty = exclude_empty)
    if raise_on_error:
        runner = DebugRunner(verbose = verbose, optionflags = optionflags)
    else:
        runner = DocTestRunner(verbose = verbose, optionflags = optionflags)
    for test in finder.find(m, name, globs = globs, extraglobs = extraglobs):
        runner.run(test)

    if report:
        runner.summarize()

    if master is None:
        master = runner
    else:
        master.merge(runner)
    return (runner.failures, runner.tries)


def testfile(filename, module_relative = True, name = None, package = None, globs = None, verbose = None, report = True, optionflags = 0, extraglobs = None, raise_on_error = False, parser = DocTestParser()):
    global master
    if package and not module_relative:
        raise ValueError('Package may only be specified for module-relative paths.')

    if module_relative:
        package = _normalize_module(package)
        filename = _module_relative_path(package, filename)

    if name is None:
        name = os.path.basename(filename)

    if globs is None:
        globs = { }
    else:
        globs = globs.copy()
    if extraglobs is not None:
        globs.update(extraglobs)

    if raise_on_error:
        runner = DebugRunner(verbose = verbose, optionflags = optionflags)
    else:
        runner = DocTestRunner(verbose = verbose, optionflags = optionflags)
    s = open(filename).read()
    test = parser.get_doctest(s, globs, name, filename, 0)
    runner.run(test)
    if report:
        runner.summarize()

    if master is None:
        master = runner
    else:
        master.merge(runner)
    return (runner.failures, runner.tries)


def run_docstring_examples(f, globs, verbose = False, name = 'NoName', compileflags = None, optionflags = 0):
    finder = DocTestFinder(verbose = verbose, recurse = False)
    runner = DocTestRunner(verbose = verbose, optionflags = optionflags)
    for test in finder.find(f, name, globs = globs):
        runner.run(test, compileflags = compileflags)



class Tester:

    def __init__(self, mod = None, globs = None, verbose = None, isprivate = None, optionflags = 0):
        warnings.warn('class Tester is deprecated; use class doctest.DocTestRunner instead', DeprecationWarning, stacklevel = 2)
        if mod is None and globs is None:
            raise TypeError('Tester.__init__: must specify mod or globs')

        if mod is not None and not inspect.ismodule(mod):
            raise TypeError('Tester.__init__: mod must be a module; %r' % (mod,))

        if globs is None:
            globs = mod.__dict__

        self.globs = globs
        self.verbose = verbose
        self.isprivate = isprivate
        self.optionflags = optionflags
        self.testfinder = DocTestFinder(_namefilter = isprivate)
        self.testrunner = DocTestRunner(verbose = verbose, optionflags = optionflags)


    def runstring(self, s, name):
        test = DocTestParser().get_doctest(s, self.globs, name, None, None)
        if self.verbose:
            print 'Running string', name

        (f, t) = self.testrunner.run(test)
        if self.verbose:
            print f, 'of', t, 'examples failed in string', name

        return (f, t)


    def rundoc(self, object, name = None, module = None):
        f = t = 0
        tests = self.testfinder.find(object, name, module = module, globs = self.globs)
        for test in tests:
            (f2, t2) = self.testrunner.run(test)
            f = f + f2
            t = t + t2

        return (f, t)


    def rundict(self, d, name, module = None):
        import new as new
        m = new.module(name)
        m.__dict__.update(d)
        if module is None:
            module = False

        return self.rundoc(m, name, module)


    def run__test__(self, d, name):
        import new
        m = new.module(name)
        m.__test__ = d
        return self.rundoc(m, name)


    def summarize(self, verbose = None):
        return self.testrunner.summarize(verbose)


    def merge(self, other):
        self.testrunner.merge(other.testrunner)


_unittest_reportflags = 0

def set_unittest_reportflags(flags):
    global _unittest_reportflags
    if flags & REPORTING_FLAGS != flags:
        raise ValueError('Only reporting flags allowed', flags)

    old = _unittest_reportflags
    _unittest_reportflags = flags
    return old


class DocTestCase(unittest.TestCase):

    def __init__(self, test, optionflags = 0, setUp = None, tearDown = None, checker = None):
        unittest.TestCase.__init__(self)
        self._dt_optionflags = optionflags
        self._dt_checker = checker
        self._dt_test = test
        self._dt_setUp = setUp
        self._dt_tearDown = tearDown


    def setUp(self):
        test = self._dt_test
        if self._dt_setUp is not None:
            self._dt_setUp(test)



    def tearDown(self):
        test = self._dt_test
        if self._dt_tearDown is not None:
            self._dt_tearDown(test)

        test.globs.clear()


    def runTest(self):
        test = self._dt_test
        old = sys.stdout
        new = StringIO()
        optionflags = self._dt_optionflags
        if not optionflags & REPORTING_FLAGS:
            optionflags |= _unittest_reportflags

        runner = DocTestRunner(optionflags = optionflags, checker = self._dt_checker, verbose = False)

        try:
            runner.DIVIDER = '-' * 70
            (failures, tries) = runner.run(test, out = new.write, clear_globs = False)
        finally:
            sys.stdout = old

        if failures:
            raise self.failureException(self.format_failure(new.getvalue()))



    def format_failure(self, err):
        test = self._dt_test
        if test.lineno is None:
            lineno = 'unknown line number'
        else:
            lineno = '%s' % test.lineno
        lname = '.'.join(test.name.split('.')[-1:])
        return 'Failed doctest test for %s\n  File "%s", line %s, in %s\n\n%s' % (test.name, test.filename, lineno, lname, err)


    def debug(self):
        self.setUp()
        runner = DebugRunner(optionflags = self._dt_optionflags, checker = self._dt_checker, verbose = False)
        runner.run(self._dt_test)
        self.tearDown()


    def id(self):
        return self._dt_test.name


    def __repr__(self):
        name = self._dt_test.name.split('.')
        return '%s (%s)' % (name[-1], '.'.join(name[:-1]))

    __str__ = __repr__

    def shortDescription(self):
        return 'Doctest: ' + self._dt_test.name



def DocTestSuite(module = None, globs = None, extraglobs = None, test_finder = None, **options):
    if test_finder is None:
        test_finder = DocTestFinder()

    module = _normalize_module(module)
    tests = test_finder.find(module, globs = globs, extraglobs = extraglobs)
    if globs is None:
        globs = module.__dict__

    if not tests:
        raise ValueError(module, 'has no tests')

    tests.sort()
    suite = unittest.TestSuite()
    for test in tests:
        if len(test.examples) == 0:
            continue

        if not test.filename:
            filename = module.__file__
            if filename[-4:] in ('.pyc', '.pyo'):
                filename = filename[:-1]

            test.filename = filename

        suite.addTest(DocTestCase(test, **options))

    return suite


class DocFileCase(DocTestCase):

    def id(self):
        return '_'.join(self._dt_test.name.split('.'))


    def __repr__(self):
        return self._dt_test.filename

    __str__ = __repr__

    def format_failure(self, err):
        return 'Failed doctest test for %s\n  File "%s", line 0\n\n%s' % (self._dt_test.name, self._dt_test.filename, err)



def DocFileTest(path, module_relative = True, package = None, globs = None, parser = DocTestParser(), **options):
    if globs is None:
        globs = { }

    if package and not module_relative:
        raise ValueError('Package may only be specified for module-relative paths.')

    if module_relative:
        package = _normalize_module(package)
        path = _module_relative_path(package, path)

    name = os.path.basename(path)
    doc = open(path).read()
    test = parser.get_doctest(doc, globs, name, path, 0)
    return DocFileCase(test, **options)


def DocFileSuite(*paths, **kw):
    suite = unittest.TestSuite()
    if kw.get('module_relative', True):
        kw['package'] = _normalize_module(kw.get('package'))

    for path in paths:
        suite.addTest(DocFileTest(path, **kw))

    return suite


def script_from_examples(s):
    output = []
    for piece in DocTestParser().parse(s):
        if isinstance(piece, Example):
            output.append(piece.source[:-1])
            want = piece.want
            if want:
                output.append('# Expected:')
                [] += [ '## ' + l for l in want.split('\n')[:-1] ]

        want
        [] += [ _comment_line(l) for l in piece.split('\n')[:-1] ]

    while output and output[-1] == '#':
        output.pop()
        continue
        []
    while output and output[0] == '#':
        output.pop(0)
        continue
        output
    return '\n'.join(output)


def testsource(module, name):
    module = _normalize_module(module)
    tests = DocTestFinder().find(module)
    test = _[1]
    test = test[0]
    testsrc = script_from_examples(test.docstring)
    return testsrc


def debug_src(src, pm = False, globs = None):
    testsrc = script_from_examples(src)
    debug_script(testsrc, pm, globs)


def debug_script(src, pm = False, globs = None):
    import pdb
    srcfilename = tempfile.mktemp('.py', 'doctestdebug')
    f = open(srcfilename, 'w')
    f.write(src)
    f.close()

    try:
        if globs:
            globs = globs.copy()
        else:
            globs = { }
        if pm:

            try:
                execfile(srcfilename, globs, globs)
            print sys.exc_info()[1]
            pdb.post_mortem(sys.exc_info()[2])

        else:
            pdb.run('execfile(%r)' % srcfilename, globs, globs)
    finally:
        os.remove(srcfilename)



def debug(module, name, pm = False):
    module = _normalize_module(module)
    testsrc = testsource(module, name)
    debug_script(testsrc, pm, module.__dict__)


class _TestClass:

    def __init__(self, val):
        self.val = val


    def square(self):
        self.val = self.val ** 2
        return self


    def get(self):
        return self.val


__test__ = {
    '_TestClass': _TestClass,
    'string': '\n                      Example of a string object, searched as-is.\n                      >>> x = 1; y = 2\n                      >>> x + y, x * y\n                      (3, 2)\n                      ',
    'bool-int equivalence': '\n                                    In 2.2, boolean expressions displayed\n                                    0 or 1.  By default, we still accept\n                                    them.  This can be disabled by passing\n                                    DONT_ACCEPT_TRUE_FOR_1 to the new\n                                    optionflags argument.\n                                    >>> 4 == 4\n                                    1\n                                    >>> 4 == 4\n                                    True\n                                    >>> 4 > 4\n                                    0\n                                    >>> 4 > 4\n                                    False\n                                    ',
    'blank lines': "\n                Blank lines can be marked with <BLANKLINE>:\n                    >>> print 'foo\\n\\nbar\\n'\n                    foo\n                    <BLANKLINE>\n                    bar\n                    <BLANKLINE>\n            ",
    'ellipsis': "\n                If the ellipsis flag is used, then '...' can be used to\n                elide substrings in the desired output:\n                    >>> print range(1000) #doctest: +ELLIPSIS\n                    [0, 1, 2, ..., 999]\n            ",
    'whitespace normalization': '\n                If the whitespace normalization flag is used, then\n                differences in whitespace are ignored.\n                    >>> print range(30) #doctest: +NORMALIZE_WHITESPACE\n                    [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,\n                     15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26,\n                     27, 28, 29]\n            ' }

def _test():
    r = unittest.TextTestRunner()
    r.run(DocTestSuite())

if __name__ == '__main__':
    _test()